
#ifndef ROBOTCONCRET_H
#define ROBOTCONCRET_H
#include "Robot.h"

#include <string>
#include <vector>

class EtatRobot;
#include "Obstacle.h"
#include "Objet.h"
#include "Position.h"
#include "Afficheur.h"
#include "NotPossibleException.h"
#include <iostream>

using namespace std;

/**
  * class RobotConcret
  * 
  */

class RobotConcret : public Robot
{
public:

  // Constructors/Destructors
  //  


  /**
   * Empty Constructor
   */
  RobotConcret ( );

  /**
   * Empty Destructor
   */
  virtual ~RobotConcret ( );

  // Static Public attributes
  //  

  // Public attributes
  //  


  EtatRobot * m_etat;

  Obstacle * m_obstacle;

  Objet * m_objet;

  Position * m_position;

  Afficheur * m_observateur;

  // Public attribute accessor methods
  //  


  // Public attribute accessor methods
  //  


  /**
   * Set the value of m_etat
   * @param new_var the new value of m_etat
   */
  void setEtat ( EtatRobot * new_var );

  /**
   * Get the value of m_etat
   * @return the value of m_etat
   */
  EtatRobot * getEtat ( );


  /**
   * Set the value of m_obstacle
   * @param new_var the new value of m_obstacle
   */
  void setObstacle ( Obstacle * new_var );

  /**
   * Get the value of m_obstacle
   * @return the value of m_obstacle
   */
  Obstacle * getObstacle ( );


  /**
   * Set the value of m_objet
   * @param new_var the new value of m_objet
   */
  void setObjet ( Objet * new_var );

  /**
   * Get the value of m_objet
   * @return the value of m_objet
   */
  Objet * getObjet ( );


  /**
   * Set the value of m_position
   * @param new_var the new value of m_position
   */
  void setPosition ( Position * new_var );

  /**
   * Get the value of m_position
   * @return the value of m_position
   */
  Position * getPosition ( );


  /**
   * Set the value of m_observateur
   * @param new_var the new value of m_observateur
   */
  void setObservateur ( Afficheur * new_var );

  /**
   * Get the value of m_observateur
   * @return the value of m_observateur
   */
  Afficheur * getObservateur ( );



  /**
   * @param  x
   * @param  y
   */
  void avancer (int x, int y )
  {
    try{
      m_etat->avancer(this);
      _avancer(x,y);

    }catch(NotPossibleException e){
      cout << "Erreur impossible d'avancer dans cet état" << endl;
    }
  }


  /**
   * @param  direction
   */
  void tourner (string direction )
  {
    try{
      m_etat->tourner();
      _tourner(direction);

    }catch(NotPossibleException e){
      cout << "Erreur impossible de trouner dans cet état" << endl;
    }
  }


  /**
   * @param  o
   */
  void saisir (Objet o )
  {
    try{
      m_etat->saisir();
      _saisir();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de saisir dans cet état" << endl;
    }
  }


  /**
   */
  void poser ( )
  {
    try{
      m_etat->poser();
      _poser();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de poser dans cet état" << endl;
    }
  }


  /**
   * @return int
   */
  int peser ( )
  {
    try{
      m_etat->peser();
      _peser();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de peser dans cette état" << endl;
    }
  }


  /**
   * @param  o
   */
  void rencontrerObstacle (Obstacle o )
  {
    try{
      m_etat->rencontrerObstacle();
      _rencontrerObstacle();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de rencontrer un obstacle dans cette état" << endl;
    }
  }


  /**
   * @return int
   */
  int evaluerObstacle ( )
  {
    try{
      m_etat->evaluerObstacle();
      _evaluerObstacle();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de evaluer un obstacle dans cette état" << endl;
    }
  }


  /**
   */
  void figer ( )
  {
    try{
      m_etat->figer();
      _figer();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de figer un obstacle dans cette état" << endl;
    }
  }


  /**
   */
  void repartir ( )
  {
    try{
      m_etat->repartir();
      _repartir();

    }catch(NotPossibleException e){
      cout << "Erreur impossible de repartir dans cette état" << endl;
    }
  }




protected:

  // Static Protected attributes
  //  

  // Protected attributes
  //  

public:


  // Protected attribute accessor methods
  //  

protected:

public:


  // Protected attribute accessor methods
  //  

protected:


private:

  // Static Private attributes
  //  

  // Private attributes
  //  

  string direction;
public:


  // Private attribute accessor methods
  //  

private:

public:


  // Private attribute accessor methods
  //  


  /**
   * Set the value of direction
   * @param new_var the new value of direction
   */
  void setDirection ( string new_var )   {
      direction = new_var;
  }

  /**
   * Get the value of direction
   * @return the value of direction
   */
  string getDirection ( )   {
    return direction;
  }
private:



  /**
   * @param  x
   * @param  y
   */
  void _avancer (int x, int y )
  {
    m_position.setX(x);
    m_position.setY(y);
  }


  /**
   * @param  direction
   */
  void _tourner (string direction )
  {
    m_position.tourner(direction);
  }


  /**
   * @param  o
   */
  void _saisir (Objet o )
  {
    m_objet = o;
  }


  /**
   * @return int
   */
  int _peser ( )
  {
    return m_objet.getPoids();
  }


  /**
   * @param  o
   */
  void _rencontrerObstacle (Obstacle o )
  {
    m_obstacle = o;
  }


  /**
   * @return int
   */
  int _evaluerObstacle ( )
  {
    m_obstacle.getHauteur();
  }


  /**
   */
  void _figer ( )
  {
    cout << "le robot est maintenant figé" << endl;
  }


  /**
   */
  void _repartir ( )
  {
    cout << "le robot repart" << endl;
  }

};

#endif // ROBOTCONCRET_H
